struct tree_common
{
	int uid;
	union tree_node *chain;
	union tree_node *type;
	enum tree_code code : 8;

	unsigned external_attr : 1;
	unsigned public_attr : 1;
	unsigned static_attr : 1;
	unsigned volatile_attr : 1;
	unsigned packed_attr : 1;
	unsigned readonly_attr : 1;
	unsigned literal_attr : 1;
	unsigned nonlocal_attr : 1;
	unsigned permanent_attr : 1;
	unsigned addressable_attr : 1;
	unsigned regdecl_attr : 1;
	unsigned this_vol_attr : 1;
	unsigned unsigned_attr : 1;
	unsigned asm_written_attr: 1;
	unsigned inline_attr : 1;
};

struct tree_int_cst
{
	char common[sizeof (struct tree_common)];
	long int_cst_low;
	long int_cst_high;
};
struct tree_real_cst
{
  char common[sizeof (struct tree_common)];
  struct rtx_def *rtl;	/* acts as link to register transfer language
				   (rtl) info */
  double real_cst;
};

struct tree_string
{
  char common[sizeof (struct tree_common)];
  struct rtx_def *rtl;	/* acts as link to register transfer language
				   (rtl) info */
  int length;
  char *pointer;
};

struct tree_complex
{
  char common[sizeof (struct tree_common)];
  struct rtx_def *rtl;	/* acts as link to register transfer language
				   (rtl) info */
  union tree_node *real;
  union tree_node *imag;
};

/* RTL expression ("rtx").  */
enum rtx_code  {
};

enum machine_mode
{
};

typedef struct rtvec_def{
	unsigned num_elem;		/* number of elements */
	rtunion elem[1];
} *rtvec;


typedef union rtunion_def
{
	int rtint;
	char *rtstr;
	struct rtx_def *rtx;
	struct rtvec_def *rtvec;
	enum machine_mode rttype;
} rtunion;


typedef struct rtx_def
{
  /* The kind of expression this is.  */
  enum rtx_code code : 16;
  /* The kind of value the expression has.  */
  enum machine_mode mode : 8;
  /* 1 in an INSN if it can alter flow of control
     within this function.  Not yet used!  */
  unsigned int jump : 1;
  /* 1 in an INSN if it can call another function.  Not yet used!  */
  unsigned int call : 1;
  /* 1 in a MEM or REG if value of this expression will never change
     during the current function, even though it is not
     manifestly constant.
     1 in a SYMBOL_REF if it addresses something in the per-function
     constants pool.  */
  unsigned int unchanging : 1;
  /* 1 in a MEM expression if contents of memory are volatile.  */
  /* 1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL or BARRIER
     if it is deleted.  */
  /* 1 in a REG expression if corresponds to a variable declared by the user.
     0 for an internally generated temporary.  */
  unsigned int volatil : 1;
  /* 1 in a MEM referring to a field of a structure (not a union!).
     0 if the MEM was a variable or the result of a * operator in C;
     1 if it was the result of a . or -> operator (on a struct) in C.  */
  unsigned int in_struct : 1;
  /* 1 if this rtx is used.  This is used for copying shared structure.
     See `unshare_all_rtl'.
     This bit is used to detect that event.  */
  unsigned int used : 1;
  /* Nonzero if this rtx came from procedure integration.  */
  unsigned integrated : 1;
  /* The first element of the operands of this rtx.
     The number of operands and their types are controlled
     by the `code' field, according to rtl.def.  */
  rtunion fld[1];
} *rtx;

struct tree_identifier
{
	char common[sizeof (struct tree_common)];
	int length;
	char *pointer;
	union tree_node *global_value;
	union tree_node *local_value;
	union tree_node *label_value;
	union tree_node *implicit_decl;
};

struct tree_decl
{
  char common[sizeof (struct tree_common)];
  char *filename;
  int linenum;
  union tree_node *size;
  enum machine_mode mode;
  unsigned char size_unit;
  unsigned char align;
  unsigned char voffset_unit;
  union tree_node *name;
  union tree_node *context;
  int offset;
  union tree_node *voffset;
  union tree_node *arguments;
  union tree_node *result;
  union tree_node *initial;
  struct rtx_def *rtl;	/* acts as link to register transfer language
				   (rtl) info */
  int frame_size;		/* For FUNCTION_DECLs: size of stack frame */
  struct rtx_def *saved_insns;	/* For FUNCTION_DECLs: points to insn that
				   constitute its definition on the
				   permanent obstack.  */
  int block_symtab_address;
};

struct tree_type
{
	char common[sizeof (struct tree_common)];
	union tree_node *values;
	union tree_node *sep;
	union tree_node *size;
	enum machine_mode mode;
	unsigned char size_unit;
	unsigned char align;
	unsigned char sep_unit;
	enum machine_mode elt_mode;	/* Unused */
	union tree_node *pointer_to;
	int parse_info;
	int symtab_address;
	union tree_node *name;
	union tree_node *max;
	union tree_node *next_variant;
	union tree_node *main_variant;
};

struct tree_list
{
	char common[sizeof (struct tree_common)];
	union tree_node *purpose;
	union tree_node *value;
};

struct tree_exp
{
	char common[sizeof (struct tree_common)];
	int complexity;
	union tree_node *operands[1];
};

struct tree_stmt
{
	char common[sizeof (struct tree_common)];
	char *filename;
	int linenum;
	union tree_node *body;
};

struct tree_if_stmt
{
	char common[sizeof (struct tree_common)];
	char *filename;
	int linenum;
	union tree_node *cond, *thenpart, *elsepart;
};

struct tree_bind_stmt
{
	char common[sizeof (struct tree_common)];
	char *filename;
	int linenum;
	union tree_node *body, *vars, *supercontext, *bind_size, *type_tags;
};

struct tree_case_stmt
{
	char common[sizeof (struct tree_common)];
	char *filename;
	int linenum;
	union tree_node *index, *case_list;
};

union tree_node
{
	struct tree_common common;
	struct tree_int_cst int_cst;
	struct tree_real_cst real_cst;
	struct tree_string string;
	struct tree_complex complex;
	struct tree_identifier identifier;
	struct tree_decl decl;
	struct tree_type type;
	struct tree_list list;
	struct tree_exp exp;
	struct tree_stmt stmt;
	struct tree_if_stmt if_stmt;
	struct tree_bind_stmt bind_stmt;
	struct tree_case_stmt case_stmt;
};